home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / binutils.7 / binutils / binutils-2.7 / gas / config / tc-h8500.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-04  |  31.5 KB  |  1,653 lines
  1. /* tc-h8500.c -- Assemble code for the Hitachi H8/500
  2.    Copyright (C) 1993 Free Software Foundation.
  3.  
  4.    This file is part of GAS, the GNU Assembler.
  5.  
  6.    GAS is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2, or (at your option)
  9.    any later version.
  10.  
  11.    GAS is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with GAS; see the file COPYING.  If not, write to
  18.    the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19.  
  20. /*
  21.   Written By Steve Chamberlain
  22.   sac@cygnus.com
  23.   */
  24.  
  25. #include <stdio.h>
  26. #include "as.h"
  27. #include "bfd.h"
  28. #include "subsegs.h"
  29. #define DEFINE_TABLE
  30. #define ASSEMBLER_TABLE
  31. #include "opcodes/h8500-opc.h"
  32. #include <ctype.h>
  33.  
  34. const char comment_chars[] = "!";
  35. const char line_separator_chars[] = ";";
  36. const char line_comment_chars[] = "!#";
  37.  
  38. /* This table describes all the machine specific pseudo-ops the assembler
  39.    has to support.  The fields are:
  40.    pseudo-op name without dot
  41.    function to call to execute this pseudo-op
  42.    Integer arg to pass to the function
  43.    */
  44.  
  45. void cons ();
  46.  
  47. const pseudo_typeS md_pseudo_table[] =
  48. {
  49.   {"int", cons, 2},
  50.   {"data.b", cons, 1},
  51.   {"data.w", cons, 2},
  52.   {"data.l", cons, 4},
  53.   {"form", listing_psize, 0},
  54.   {"heading", listing_title, 0},
  55.   {"import", s_ignore, 0},
  56.   {"page", listing_eject, 0},
  57.   {"program", s_ignore, 0},
  58.   {0, 0, 0}
  59. };
  60.  
  61. const int md_reloc_size;
  62.  
  63. const char EXP_CHARS[] = "eE";
  64.  
  65. /* Chars that mean this number is a floating point constant */
  66. /* As in 0f12.456 */
  67. /* or    0d1.2345e12 */
  68. const char FLT_CHARS[] = "rRsSfFdDxXpP";
  69.  
  70. #define C(a,b) ENCODE_RELAX(a,b)
  71. #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
  72.  
  73. #define GET_WHAT(x) ((x>>2))
  74.  
  75. #define BYTE_DISP 1
  76. #define WORD_DISP 2
  77. #define UNDEF_BYTE_DISP 0
  78. #define UNDEF_WORD_DISP 3
  79.  
  80. #define BRANCH  1
  81. #define SCB_F   2
  82. #define SCB_TST 3
  83. #define END 4
  84.  
  85. #define BYTE_F 127
  86. #define BYTE_B -126
  87. #define WORD_F 32767
  88. #define WORD_B 32768
  89.  
  90. relax_typeS md_relax_table[C (END, 0)];
  91.  
  92. static struct hash_control *opcode_hash_control;    /* Opcode mnemonics */
  93.  
  94. /*
  95.   This function is called once, at assembler startup time.  This should
  96.   set up all the tables, etc that the MD part of the assembler needs
  97.   */
  98.  
  99. void
  100. md_begin ()
  101. {
  102.   h8500_opcode_info *opcode;
  103.   char prev_buffer[100];
  104.   int idx = 0;
  105.   register relax_typeS *table;
  106.  
  107.   opcode_hash_control = hash_new ();
  108.   prev_buffer[0] = 0;
  109.  
  110.   /* Insert unique names into hash table */
  111.   for (opcode = h8500_table; opcode->name; opcode++)
  112.     {
  113.       if (idx != opcode->idx)
  114.     {
  115.       hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  116.       idx++;
  117.     }
  118.     }
  119.  
  120.   /* Initialize the relax table.  We use a local variable to avoid
  121.      warnings about modifying a supposedly const data structure.  */
  122.   table = (relax_typeS *) md_relax_table;
  123.   table[C (BRANCH, BYTE_DISP)].rlx_forward = BYTE_F;
  124.   table[C (BRANCH, BYTE_DISP)].rlx_backward = BYTE_B;
  125.   table[C (BRANCH, BYTE_DISP)].rlx_length = 2;
  126.   table[C (BRANCH, BYTE_DISP)].rlx_more = C (BRANCH, WORD_DISP);
  127.  
  128.   table[C (BRANCH, WORD_DISP)].rlx_forward = WORD_F;
  129.   table[C (BRANCH, WORD_DISP)].rlx_backward = WORD_B;
  130.   table[C (BRANCH, WORD_DISP)].rlx_length = 3;
  131.   table[C (BRANCH, WORD_DISP)].rlx_more = 0;
  132.  
  133.   table[C (SCB_F, BYTE_DISP)].rlx_forward = BYTE_F;
  134.   table[C (SCB_F, BYTE_DISP)].rlx_backward = BYTE_B;
  135.   table[C (SCB_F, BYTE_DISP)].rlx_length = 3;
  136.   table[C (SCB_F, BYTE_DISP)].rlx_more = C (SCB_F, WORD_DISP);
  137.  
  138.   table[C (SCB_F, WORD_DISP)].rlx_forward = WORD_F;
  139.   table[C (SCB_F, WORD_DISP)].rlx_backward = WORD_B;
  140.   table[C (SCB_F, WORD_DISP)].rlx_length = 8;
  141.   table[C (SCB_F, WORD_DISP)].rlx_more = 0;
  142.  
  143.   table[C (SCB_TST, BYTE_DISP)].rlx_forward = BYTE_F;
  144.   table[C (SCB_TST, BYTE_DISP)].rlx_backward = BYTE_B;
  145.   table[C (SCB_TST, BYTE_DISP)].rlx_length = 3;
  146.   table[C (SCB_TST, BYTE_DISP)].rlx_more = C (SCB_TST, WORD_DISP);
  147.  
  148.   table[C (SCB_TST, WORD_DISP)].rlx_forward = WORD_F;
  149.   table[C (SCB_TST, WORD_DISP)].rlx_backward = WORD_B;
  150.   table[C (SCB_TST, WORD_DISP)].rlx_length = 10;
  151.   table[C (SCB_TST, WORD_DISP)].rlx_more = 0;
  152.  
  153. }
  154.  
  155. static int rn;            /* register number used by RN */
  156. static int rs;            /* register number used by RS */
  157. static int rd;            /* register number used by RD */
  158. static int crb;            /* byte size cr */
  159. static int crw;            /* word sized cr */
  160. static int cr;            /* unknown size cr */
  161.  
  162. static expressionS displacement;/* displacement expression */
  163. static int displacement_size;    /* and size if given */
  164.  
  165. static int immediate_inpage;
  166. static expressionS immediate;    /* immediate expression */
  167. static int immediate_size;    /* and size if given */
  168.  
  169. static expressionS absolute;    /* absolute expression */
  170. static int absolute_size;    /* and size if given */
  171.  
  172. typedef struct
  173. {
  174.   int type;
  175.   int reg;
  176.   expressionS exp;
  177.   int page;
  178. }
  179.  
  180. h8500_operand_info;
  181.  
  182. /* try and parse a reg name, returns number of chars consumed */
  183. static int
  184. parse_reg (src, mode, reg)
  185.      char *src;
  186.      int *mode;
  187.      int *reg;
  188. {
  189.   if (src[0] == 'r')
  190.     {
  191.       if (src[1] >= '0' && src[1] <= '7')
  192.     {
  193.       *mode = RN;
  194.       *reg = (src[1] - '0');
  195.       return 2;
  196.     }
  197.     }
  198.  
  199.   if (src[0] == 's' && src[1] == 'p')
  200.     {
  201.       *mode = RN;
  202.       *reg = 7;
  203.       return 2;
  204.     }
  205.   if (src[0] == 'c' && src[1] == 'c' && src[2] == 'r')
  206.     {
  207.       *mode = CRB;
  208.       *reg = 1;
  209.       return 3;
  210.     }
  211.   if (src[0] == 's' && src[1] == 'r')
  212.     {
  213.       *mode = CRW;
  214.       *reg = 0;
  215.       return 2;
  216.     }
  217.  
  218.   if (src[0] == 'b' && src[1] == 'r')
  219.     {
  220.       *mode = CRB;
  221.       *reg = 3;
  222.       return 2;
  223.     }
  224.  
  225.   if (src[0] == 'e' && src[1] == 'p')
  226.     {
  227.       *mode = CRB;
  228.       *reg = 4;
  229.       return 2;
  230.     }
  231.  
  232.   if (src[0] == 'd' && src[1] == 'p')
  233.     {
  234.       *mode = CRB;
  235.       *reg = 5;
  236.       return 2;
  237.     }
  238.  
  239.   if (src[0] == 't' && src[1] == 'p')
  240.     {
  241.       *mode = CRB;
  242.       *reg = 7;
  243.       return 2;
  244.     }
  245.  
  246.   if (src[0] == 'f' && src[1] == 'p')
  247.     {
  248.       *mode = RN;
  249.       *reg = 6;
  250.       return 2;
  251.     }
  252.   return 0;
  253. }
  254.  
  255. static
  256. char *
  257. parse_exp (s, op, page)
  258.      char *s;
  259.      expressionS *op;
  260.      int *page;
  261. {
  262.   char *save;
  263.   char *new;
  264.  
  265.   save = input_line_pointer;
  266.  
  267.   *page = 0;
  268.   if (s[0] == '%')
  269.     {
  270.       if (s[1] == 'p' && s[2] == 'a' && s[3] == 'g' && s[4] == 'e')
  271.     {
  272.       s += 5;
  273.       *page = 'p';
  274.     }
  275.       if (s[1] == 'h' && s[2] == 'i' && s[3] == '1' && s[4] == '6')
  276.     {
  277.       s += 5;
  278.       *page = 'h';
  279.     }
  280.       else if (s[1] == 'o' && s[2] == 'f' && s[3] == 'f')
  281.     {
  282.       s += 4;
  283.       *page = 'o';
  284.     }
  285.     }
  286.  
  287.   input_line_pointer = s;
  288.  
  289.   expression (op);
  290.   if (op->X_op == O_absent)
  291.     as_bad ("missing operand");
  292.   new = input_line_pointer;
  293.   input_line_pointer = save;
  294.   return new;
  295. }
  296.  
  297. typedef enum
  298.   {
  299.     exp_signed, exp_unsigned, exp_sandu
  300.   } sign_type;
  301.  
  302.  
  303. static char *
  304. skip_colonthing (sign, ptr, exp, def, size8, size16, size24)
  305.      sign_type sign;
  306.      char *ptr;
  307.      h8500_operand_info *exp;
  308.      int def;
  309.      int size8;
  310.      int size16;
  311.      int size24;
  312. {
  313.   ptr = parse_exp (ptr, &exp->exp, &exp->page);
  314.   if (*ptr == ':')
  315.     {
  316.       ptr++;
  317.       if (*ptr == '8')
  318.     {
  319.       ptr++;
  320.       exp->type = size8;
  321.     }
  322.       else if (ptr[0] == '1' & ptr[1] == '6')
  323.     {
  324.       ptr += 2;
  325.       exp->type = size16;
  326.     }
  327.       else if (ptr[0] == '2' & ptr[1] == '4')
  328.     {
  329.       if (!size24)
  330.         {
  331.           as_bad (":24 not valid for this opcode");
  332.         }
  333.       ptr += 2;
  334.       exp->type = size24;
  335.     }
  336.       else
  337.     {
  338.       as_bad ("expect :8,:16 or :24");
  339.       exp->type = size16;
  340.     }
  341.     }
  342.   else
  343.     {
  344.       if (exp->page == 'p')
  345.     {
  346.       exp->type = IMM8;
  347.     }
  348.       else if (exp->page == 'h')
  349.     {
  350.       exp->type = IMM16;
  351.     }
  352.       else
  353.     {
  354.       /* Let's work out the size from the context */
  355.       int n = exp->exp.X_add_number;
  356.       if (size8
  357.           && exp->exp.X_op == O_constant
  358.           && ((sign == exp_signed && (n >= -128 && n <= 127))
  359.           || (sign == exp_unsigned && (n >= 0 && (n <= 255)))
  360.           || (sign == exp_sandu && (n >= -128 && (n <= 255)))))
  361.         {
  362.           exp->type = size8;
  363.         }
  364.       else
  365.         {
  366.           exp->type = def;
  367.         }
  368.     }
  369.     }
  370.   return ptr;
  371. }
  372.  
  373. static int
  374. parse_reglist (src, op)
  375.      char *src;
  376.      h8500_operand_info *op;
  377. {
  378.   int mode;
  379.   int rn;
  380.   int mask = 0;
  381.   int rm;
  382.   int idx = 1;            /* skip ( */
  383.  
  384.   while (src[idx] && src[idx] != ')')
  385.     {
  386.       int done = parse_reg (src + idx, &mode, &rn);
  387.  
  388.       if (done)
  389.     {
  390.       idx += done;
  391.       mask |= 1 << rn;
  392.     }
  393.       else
  394.     {
  395.       as_bad ("syntax error in reg list");
  396.       return 0;
  397.     }
  398.       if (src[idx] == '-')
  399.     {
  400.       idx++;
  401.       done = parse_reg (src + idx, &mode, &rm);
  402.       if (done)
  403.         {
  404.           idx += done;
  405.           while (rn <= rm)
  406.         {
  407.           mask |= 1 << rn;
  408.           rn++;
  409.         }
  410.         }
  411.       else
  412.         {
  413.           as_bad ("missing final register in range");
  414.         }
  415.     }
  416.       if (src[idx] == ',')
  417.     idx++;
  418.     }
  419.   idx++;
  420.   op->exp.X_add_symbol = 0;
  421.   op->exp.X_op_symbol = 0;
  422.   op->exp.X_add_number = mask;
  423.   op->exp.X_op = O_constant;
  424.   op->exp.X_unsigned = 1;
  425.   op->type = IMM8;
  426.   return idx;
  427.  
  428. }
  429.  
  430. /* The many forms of operand:
  431.  
  432.    Rn            Register direct
  433.    @Rn            Register indirect
  434.    @(disp[:size], Rn)    Register indirect with displacement
  435.    @Rn+
  436.    @-Rn
  437.    @aa[:size]        absolute
  438.    #xx[:size]        immediate data
  439.  
  440.    */
  441.  
  442. static void
  443. get_operand (ptr, op, ispage)
  444.      char **ptr;
  445.      h8500_operand_info *op;
  446.      char ispage;
  447. {
  448.   char *src = *ptr;
  449.   int mode;
  450.   unsigned int num;
  451.   unsigned int len;
  452.   op->page = 0;
  453.   if (src[0] == '(' && src[1] == 'r')
  454.     {
  455.       /* This is a register list */
  456.       *ptr = src + parse_reglist (src, op);
  457.       return;
  458.     }
  459.  
  460.   len = parse_reg (src, &op->type, &op->reg);
  461.  
  462.   if (len)
  463.     {
  464.       *ptr = src + len;
  465.       return;
  466.     }
  467.  
  468.   if (*src == '@')
  469.     {
  470.       src++;
  471.       if (*src == '-')
  472.     {
  473.       src++;
  474.       len = parse_reg (src, &mode, &num);
  475.       if (len == 0)
  476.         {
  477.           /* Oops, not a reg after all, must be ordinary exp */
  478.           src--;
  479.           /* must be a symbol */
  480.           *ptr = skip_colonthing (exp_unsigned, src,
  481.                       op, ABS16, ABS8, ABS16, ABS24);
  482.           return;
  483.         }
  484.  
  485.       op->type = RNDEC;
  486.       op->reg = num;
  487.       *ptr = src + len;
  488.       return;
  489.     }
  490.       if (*src == '(')
  491.     {
  492.       /* Disp */
  493.       src++;
  494.  
  495.       src = skip_colonthing (exp_signed, src, 
  496.                  op, RNIND_D16, RNIND_D8, RNIND_D16, 0);
  497.  
  498.       if (*src != ',')
  499.         {
  500.           as_bad ("expected @(exp, Rn)");
  501.           return;
  502.         }
  503.       src++;
  504.       len = parse_reg (src, &mode, &op->reg);
  505.       if (len == 0 || mode != RN)
  506.         {
  507.           as_bad ("expected @(exp, Rn)");
  508.           return;
  509.         }
  510.       src += len;
  511.       if (*src != ')')
  512.         {
  513.           as_bad ("expected @(exp, Rn)");
  514.           return;
  515.         }
  516.       *ptr = src + 1;
  517.       return;
  518.     }
  519.       len = parse_reg (src, &mode, &num);
  520.  
  521.       if (len)
  522.     {
  523.       src += len;
  524.       if (*src == '+')
  525.         {
  526.           src++;
  527.           if (mode != RN)
  528.         {
  529.           as_bad ("@Rn+ needs word register");
  530.           return;
  531.         }
  532.           op->type = RNINC;
  533.           op->reg = num;
  534.           *ptr = src;
  535.           return;
  536.         }
  537.       if (mode != RN)
  538.         {
  539.           as_bad ("@Rn needs word register");
  540.           return;
  541.         }
  542.       op->type = RNIND;
  543.       op->reg = num;
  544.       *ptr = src;
  545.       return;
  546.     }
  547.       else
  548.     {
  549.       /* must be a symbol */
  550.       *ptr =
  551.         skip_colonthing (exp_unsigned, src, op,
  552.                  ispage ? ABS24 : ABS16, ABS8, ABS16, ABS24);
  553.       return;
  554.     }
  555.     }
  556.  
  557.   if (*src == '#')
  558.     {
  559.       src++;
  560.       *ptr = skip_colonthing (exp_sandu, src, op, IMM16, IMM8, IMM16, ABS24);
  561.       return;
  562.     }
  563.   else
  564.     {
  565.       *ptr = skip_colonthing (exp_signed, src, op,
  566.                   ispage ? ABS24 : PCREL8, PCREL8, PCREL16, ABS24);
  567.     }
  568. }
  569.  
  570. static
  571. char *
  572. get_operands (info, args, operand)
  573.      h8500_opcode_info *info;
  574.      char *args;
  575.      h8500_operand_info *operand;
  576.  
  577. {
  578.   char *ptr = args;
  579.  
  580.   switch (info->nargs)
  581.     {
  582.     case 0:
  583.       operand[0].type = 0;
  584.       operand[1].type = 0;
  585.       break;
  586.  
  587.     case 1:
  588.       ptr++;
  589.       get_operand (&ptr, operand + 0, info->name[0] == 'p');
  590.       operand[1].type = 0;
  591.       break;
  592.  
  593.     case 2:
  594.       ptr++;
  595.       get_operand (&ptr, operand + 0, 0);
  596.       if (*ptr == ',')
  597.     ptr++;
  598.       get_operand (&ptr, operand + 1, 0);
  599.       break;
  600.  
  601.     default:
  602.       abort ();
  603.     }
  604.  
  605.   return ptr;
  606. }
  607.  
  608. /* Passed a pointer to a list of opcodes which use different
  609.    addressing modes, return the opcode which matches the opcodes
  610.    provided
  611.    */
  612.  
  613. int pcrel8;            /* Set when we've seen a pcrel operand */
  614.  
  615. static
  616. h8500_opcode_info *
  617. get_specific (opcode, operands)
  618.      h8500_opcode_info *opcode;
  619.      h8500_operand_info *operands;
  620. {
  621.   h8500_opcode_info *this_try = opcode;
  622.   int found = 0;
  623.   unsigned int noperands = opcode->nargs;
  624.  
  625.   unsigned int this_index = opcode->idx;
  626.  
  627.   while (this_index == opcode->idx && !found)
  628.     {
  629.       unsigned int i;
  630.  
  631.       this_try = opcode++;
  632.  
  633.       /* look at both operands needed by the opcodes and provided by
  634.        the user*/
  635.       for (i = 0; i < noperands; i++)
  636.     {
  637.       h8500_operand_info *user = operands + i;
  638.  
  639.       switch (this_try->arg_type[i])
  640.         {
  641.         case FPIND_D8:
  642.           /* Opcode needs (disp:8,fp) */
  643.           if (user->type == RNIND_D8 && user->reg == 6)
  644.         {
  645.           displacement = user->exp;
  646.           continue;
  647.         }
  648.           break;
  649.         case RDIND_D16:
  650.           if (user->type == RNIND_D16)
  651.         {
  652.           displacement = user->exp;
  653.           rd = user->reg;
  654.           continue;
  655.         }
  656.           break;
  657.         case RDIND_D8:
  658.           if (user->type == RNIND_D8)
  659.         {
  660.           displacement = user->exp;
  661.           rd = user->reg;
  662.           continue;
  663.         }
  664.           break;
  665.         case RNIND_D16:
  666.         case RNIND_D8:
  667.           if (user->type == this_try->arg_type[i])
  668.         {
  669.           displacement = user->exp;
  670.           rn = user->reg;
  671.           continue;
  672.         }
  673.           break;
  674.  
  675.         case SPDEC:
  676.           if (user->type == RNDEC && user->reg == 7)
  677.         {
  678.           continue;
  679.         }
  680.           break;
  681.         case SPINC:
  682.           if (user->type == RNINC && user->reg == 7)
  683.         {
  684.           continue;
  685.         }
  686.           break;
  687.         case ABS16:
  688.           if (user->type == ABS16)
  689.         {
  690.           absolute = user->exp;
  691.           continue;
  692.         }
  693.           break;
  694.         case ABS8:
  695.           if (user->type == ABS8)
  696.         {
  697.           absolute = user->exp;
  698.           continue;
  699.         }
  700.           break;
  701.         case ABS24:
  702.           if (user->type == ABS24)
  703.         {
  704.           absolute = user->exp;
  705.           continue;
  706.         }
  707.           break;
  708.  
  709.         case CRB:
  710.           if ((user->type == CRB || user->type == CR) && user->reg != 0)
  711.         {
  712.           crb = user->reg;
  713.           continue;
  714.         }
  715.           break;
  716.         case CRW:
  717.           if ((user->type == CRW || user->type == CR) && user->reg == 0)
  718.         {
  719.           crw = user->reg;
  720.           continue;
  721.         }
  722.           break;
  723.         case DISP16:
  724.           if (user->type == DISP16)
  725.         {
  726.           displacement = user->exp;
  727.           continue;
  728.         }
  729.           break;
  730.         case DISP8:
  731.           if (user->type == DISP8)
  732.         {
  733.           displacement = user->exp;
  734.           continue;
  735.         }
  736.           break;
  737.         case FP:
  738.           if (user->type == RN && user->reg == 6)
  739.         {
  740.           continue;
  741.         }
  742.           break;
  743.         case PCREL16:
  744.           if (user->type == PCREL16)
  745.         {
  746.           displacement = user->exp;
  747.           continue;
  748.         }
  749.           break;
  750.         case PCREL8:
  751.           if (user->type == PCREL8)
  752.         {
  753.           displacement = user->exp;
  754.           pcrel8 = 1;
  755.           continue;
  756.         }
  757.           break;
  758.  
  759.         case IMM16:
  760.           if (user->type == IMM16
  761.           || user->type == IMM8)
  762.         {
  763.           immediate_inpage = user->page;
  764.           immediate = user->exp;
  765.           continue;
  766.         }
  767.           break;
  768.         case RLIST:
  769.         case IMM8:
  770.           if (user->type == IMM8)
  771.         {
  772.           immediate_inpage = user->page;
  773.           immediate = user->exp;
  774.           continue;
  775.         }
  776.           break;
  777.         case IMM4:
  778.           if (user->type == IMM8)
  779.         {
  780.           immediate_inpage = user->page;
  781.           immediate = user->exp;
  782.           continue;
  783.         }
  784.           break;
  785.         case QIM:
  786.           if (user->type == IMM8
  787.           && user->exp.X_op == O_constant
  788.           &&
  789.           (user->exp.X_add_number == -2
  790.            || user->exp.X_add_number == -1
  791.            || user->exp.X_add_number == 1
  792.            || user->exp.X_add_number == 2))
  793.         {
  794.           immediate_inpage = user->page;
  795.           immediate = user->exp;
  796.           continue;
  797.         }
  798.           break;
  799.         case RD:
  800.           if (user->type == RN)
  801.         {
  802.           rd = user->reg;
  803.           continue;
  804.         }
  805.           break;
  806.         case RS:
  807.           if (user->type == RN)
  808.         {
  809.           rs = user->reg;
  810.           continue;
  811.         }
  812.           break;
  813.         case RDIND:
  814.           if (user->type == RNIND)
  815.         {
  816.           rd = user->reg;
  817.           continue;
  818.  
  819.         }
  820.           break;
  821.         case RNINC:
  822.         case RNIND:
  823.         case RNDEC:
  824.         case RN:
  825.  
  826.           if (user->type == this_try->arg_type[i])
  827.         {
  828.           rn = user->reg;
  829.           continue;
  830.         }
  831.           break;
  832.         case SP:
  833.           if (user->type == RN && user->reg == 7)
  834.         {
  835.           continue;
  836.         }
  837.           break;
  838.         default:
  839.           printf ("unhandled %d\n", this_try->arg_type[i]);
  840.           break;
  841.         }
  842.  
  843.       /* If we get here this didn't work out */
  844.       goto fail;
  845.     }
  846.       found = 1;
  847.     fail:;
  848.  
  849.     }
  850.  
  851.   if (found)
  852.     return this_try;
  853.   else
  854.     return 0;
  855. }
  856.  
  857. int
  858. check (operand, low, high)
  859.      expressionS *operand;
  860.      int low;
  861.      int high;
  862. {
  863.   if (operand->X_op != O_constant
  864.       || operand->X_add_number < low
  865.       || operand->X_add_number > high)
  866.     {
  867.       as_bad ("operand must be absolute in range %d..%d", low, high);
  868.     }
  869.   return operand->X_add_number;
  870. }
  871.  
  872. static
  873. void
  874. insert (output, index, exp, reloc, pcrel)
  875.      char *output;
  876.      int index;
  877.      expressionS *exp;
  878.      int reloc;
  879.      int pcrel;
  880. {
  881.   fix_new_exp (frag_now,
  882.            output - frag_now->fr_literal + index,
  883.            4,               /* always say size is 4, but we know better */
  884.            exp,
  885.            pcrel,
  886.            reloc);
  887. }
  888.  
  889. void
  890. build_relaxable_instruction (opcode, operand)
  891.      h8500_opcode_info *opcode;
  892.      h8500_operand_info *operand;
  893. {
  894.   /* All relaxable instructions start life as two bytes but can become
  895.      three bytes long if a lonely branch and up to 9 bytes if long scb
  896.      */
  897.   char *p;
  898.   int len;
  899.   int type;
  900.  
  901.   if (opcode->bytes[0].contents == 0x01)
  902.     {
  903.       type = SCB_F;
  904.     }
  905.   else if (opcode->bytes[0].contents == 0x06
  906.        || opcode->bytes[0].contents == 0x07)
  907.     {
  908.       type = SCB_TST;
  909.     }
  910.   else
  911.     {
  912.       type = BRANCH;
  913.     }
  914.  
  915.   p = frag_var (rs_machine_dependent,
  916.         md_relax_table[C (type, WORD_DISP)].rlx_length,
  917.         len = md_relax_table[C (type, BYTE_DISP)].rlx_length,
  918.         C (type, UNDEF_BYTE_DISP),
  919.         displacement.X_add_symbol,
  920.         displacement.X_add_number,
  921.         0);
  922.  
  923.   p[0] = opcode->bytes[0].contents;
  924.   if (type != BRANCH)
  925.     {
  926.       p[1] = opcode->bytes[1].contents | rs;
  927.     }
  928. }
  929.  
  930. /* Now we know what sort of opcodes it is, lets build the bytes -
  931.  */
  932. static void
  933. build_bytes (opcode, operand)
  934.      h8500_opcode_info *opcode;
  935.      h8500_operand_info *operand;
  936.  
  937. {
  938.   int index;
  939.  
  940.   if (pcrel8)
  941.     {
  942.       pcrel8 = 0;
  943.       build_relaxable_instruction (opcode, operand);
  944.     }
  945.   else
  946.     {
  947.       char *output = frag_more (opcode->length);
  948.  
  949.       memset (output, 0, opcode->length);
  950.       for (index = 0; index < opcode->length; index++)
  951.     {
  952.       output[index] = opcode->bytes[index].contents;
  953.  
  954.       switch (opcode->bytes[index].insert)
  955.         {
  956.         default:
  957.           printf ("failed for %d\n", opcode->bytes[index].insert);
  958.           break;
  959.         case 0:
  960.           break;
  961.         case RN:
  962.           output[index] |= rn;
  963.           break;
  964.         case RD:
  965.         case RDIND:
  966.           
  967.           output[index] |= rd;
  968.           break;
  969.         case RS:
  970.           output[index] |= rs;
  971.           break;
  972.         case DISP16:
  973.           insert (output, index, &displacement, R_H8500_IMM16, 0);
  974.           index++;
  975.           break;
  976.         case DISP8:
  977.         case FPIND_D8:
  978.           insert (output, index, &displacement, R_H8500_IMM8, 0);
  979.           break;
  980.  
  981.         case IMM16:
  982.           {
  983.         int p;
  984.         switch (immediate_inpage) {
  985.         case 'p':
  986.           p = R_H8500_HIGH16;
  987.           break;
  988.         case 'h':        
  989.           p = R_H8500_HIGH16;
  990.           break;
  991.         default:
  992.           p = R_H8500_IMM16;
  993.           break;
  994.         }
  995.         
  996.         insert (output, index, &immediate,p, 0);
  997.           }
  998.         
  999.           index++;
  1000.           break;
  1001.         case RLIST:
  1002.         case IMM8:
  1003.           if (immediate_inpage)
  1004.         {
  1005.           insert (output, index, &immediate, R_H8500_HIGH8, 0);
  1006.         }
  1007.           else
  1008.         {
  1009.           insert (output, index, &immediate, R_H8500_IMM8, 0);
  1010.         }
  1011.           break;
  1012.         case PCREL16:
  1013.           insert (output, index, &displacement, R_H8500_PCREL16, 1);
  1014.           index++;
  1015.           break;
  1016.         case PCREL8:
  1017.           insert (output, index, &displacement, R_H8500_PCREL8, 1);
  1018.           break;
  1019.         case IMM4:
  1020.           output[index] |= check (&immediate, 0, 15);
  1021.           break;
  1022.         case CR:
  1023.  
  1024.           output[index] |= cr;
  1025.           if (cr == 0)
  1026.         {
  1027.           output[0] |= 0x8;
  1028.         }
  1029.           else
  1030.         {
  1031.           output[0] &= ~0x8;
  1032.         }
  1033.  
  1034.           break;
  1035.  
  1036.         case CRB:
  1037.           output[index] |= crb;
  1038.           output[0] &= ~0x8;
  1039.           break;
  1040.         case CRW:
  1041.           output[index] |= crw;
  1042.           output[0] |= 0x8;
  1043.           break;
  1044.         case ABS24:
  1045.           insert (output, index, &absolute, R_H8500_IMM24, 0);
  1046.           index += 2;
  1047.           break;
  1048.         case ABS16:
  1049.           insert (output, index, &absolute, R_H8500_IMM16, 0);
  1050.           index++;
  1051.           break;
  1052.         case ABS8:
  1053.           insert (output, index, &absolute, R_H8500_IMM8, 0);
  1054.           break;
  1055.         case QIM:
  1056.           switch (immediate.X_add_number)
  1057.         {
  1058.         case -2:
  1059.           output[index] |= 0x5;
  1060.           break;
  1061.         case -1:
  1062.           output[index] |= 0x4;
  1063.           break;
  1064.         case 1:
  1065.           output[index] |= 0;
  1066.           break;
  1067.         case 2:
  1068.           output[index] |= 1;
  1069.           break;
  1070.         }
  1071.           break;
  1072.         }
  1073.     }
  1074.     }
  1075. }
  1076.  
  1077. /* This is the guts of the machine-dependent assembler.  STR points to a
  1078.    machine dependent instruction.  This funciton is supposed to emit
  1079.    the frags/bytes it assembles to.
  1080.    */
  1081.  
  1082. void
  1083. DEFUN (md_assemble, (str),
  1084.        char *str)
  1085. {
  1086.   char *op_start;
  1087.   char *op_end;
  1088.   h8500_operand_info operand[2];
  1089.   h8500_opcode_info *opcode;
  1090.   h8500_opcode_info *prev_opcode;
  1091.   char name[11];
  1092.  
  1093.   int nlen = 0;
  1094.  
  1095.   /* Drop leading whitespace */
  1096.   while (*str == ' ')
  1097.     str++;
  1098.  
  1099.   /* find the op code end */
  1100.   for (op_start = op_end = str;
  1101.        *op_end &&
  1102.        !is_end_of_line[*op_end] && *op_end != ' ';
  1103.        op_end++)
  1104.     {
  1105.       if (            /**op_end != '.'
  1106.       && *op_end != ':'
  1107.                            && */ nlen < 10)
  1108.     {
  1109.       name[nlen++] = *op_end;
  1110.     }
  1111.     }
  1112.   name[nlen] = 0;
  1113.  
  1114.   if (op_end == op_start)
  1115.     {
  1116.       as_bad ("can't find opcode ");
  1117.     }
  1118.  
  1119.   opcode = (h8500_opcode_info *) hash_find (opcode_hash_control, name);
  1120.  
  1121.   if (opcode == NULL)
  1122.     {
  1123.       as_bad ("unknown opcode");
  1124.       return;
  1125.     }
  1126.  
  1127.   get_operands (opcode, op_end, operand);
  1128.   prev_opcode = opcode;
  1129.  
  1130.   opcode = get_specific (opcode, operand);
  1131.  
  1132.   if (opcode == 0)
  1133.     {
  1134.       /* Couldn't find an opcode which matched the operands */
  1135.       char *where = frag_more (2);
  1136.  
  1137.       where[0] = 0x0;
  1138.       where[1] = 0x0;
  1139.       as_bad ("invalid operands for opcode");
  1140.       return;
  1141.     }
  1142.  
  1143.   build_bytes (opcode, operand);
  1144.  
  1145. }
  1146.  
  1147. void
  1148. DEFUN (tc_crawl_symbol_chain, (headers),
  1149.        object_headers * headers)
  1150. {
  1151.   printf ("call to tc_crawl_symbol_chain \n");
  1152. }
  1153.  
  1154. symbolS *
  1155. DEFUN (md_undefined_symbol, (name),
  1156.        char *name)
  1157. {
  1158.   return 0;
  1159. }
  1160.  
  1161. void
  1162. DEFUN (tc_headers_hook, (headers),
  1163.        object_headers * headers)
  1164. {
  1165.   printf ("call to tc_headers_hook \n");
  1166. }
  1167.  
  1168. /* Various routines to kill one day */
  1169. /* Equal to MAX_PRECISION in atof-ieee.c */
  1170. #define MAX_LITTLENUMS 6
  1171.  
  1172. /* Turn a string in input_line_pointer into a floating point constant of type
  1173.    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
  1174.    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
  1175.    */
  1176. char *
  1177. md_atof (type, litP, sizeP)
  1178.      char type;
  1179.      char *litP;
  1180.      int *sizeP;
  1181. {
  1182.   int prec;
  1183.   LITTLENUM_TYPE words[MAX_LITTLENUMS];
  1184.   LITTLENUM_TYPE *wordP;
  1185.   char *t;
  1186.   char *atof_ieee ();
  1187.  
  1188.   switch (type)
  1189.     {
  1190.     case 'f':
  1191.     case 'F':
  1192.     case 's':
  1193.     case 'S':
  1194.       prec = 2;
  1195.       break;
  1196.  
  1197.     case 'd':
  1198.     case 'D':
  1199.     case 'r':
  1200.     case 'R':
  1201.       prec = 4;
  1202.       break;
  1203.  
  1204.     case 'x':
  1205.     case 'X':
  1206.       prec = 6;
  1207.       break;
  1208.  
  1209.     case 'p':
  1210.     case 'P':
  1211.       prec = 6;
  1212.       break;
  1213.  
  1214.     default:
  1215.       *sizeP = 0;
  1216.       return "Bad call to MD_ATOF()";
  1217.     }
  1218.   t = atof_ieee (input_line_pointer, type, words);
  1219.   if (t)
  1220.     input_line_pointer = t;
  1221.  
  1222.   *sizeP = prec * sizeof (LITTLENUM_TYPE);
  1223.   for (wordP = words; prec--;)
  1224.     {
  1225.       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
  1226.       litP += sizeof (LITTLENUM_TYPE);
  1227.     }
  1228.   return 0;
  1229. }
  1230.  
  1231. CONST char *md_shortopts = "";
  1232. struct option md_longopts[] = {
  1233.   {NULL, no_argument, NULL, 0}
  1234. };
  1235. size_t md_longopts_size = sizeof(md_longopts);
  1236.  
  1237. int
  1238. md_parse_option (c, arg)
  1239.      int c;
  1240.      char *arg;
  1241. {
  1242.   return 0;
  1243. }
  1244.  
  1245. void
  1246. md_show_usage (stream)
  1247.      FILE *stream;
  1248. {
  1249. }
  1250.  
  1251. int md_short_jump_size;
  1252.  
  1253. void
  1254. tc_aout_fix_to_chars ()
  1255. {
  1256.   printf ("call to tc_aout_fix_to_chars \n");
  1257.   abort ();
  1258. }
  1259.  
  1260. void
  1261. md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
  1262.      char *ptr;
  1263.      addressT from_addr;
  1264.      addressT to_addr;
  1265.      fragS *frag;
  1266.      symbolS *to_symbol;
  1267. {
  1268.   as_fatal ("failed sanity check.");
  1269. }
  1270.  
  1271. void
  1272. md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
  1273.      char *ptr;
  1274.      addressT from_addr, to_addr;
  1275.      fragS *frag;
  1276.      symbolS *to_symbol;
  1277. {
  1278.   as_fatal ("failed sanity check.");
  1279. }
  1280.  
  1281. static
  1282. void
  1283. wordify_scb (buffer, disp_size, inst_size)
  1284.      char *buffer;
  1285.      int *disp_size;
  1286.      int *inst_size;
  1287. {
  1288.   int rn = buffer[1] & 0x7;
  1289.  
  1290.   switch (buffer[0])
  1291.     {
  1292.     case 0x0e:            /* BSR */
  1293.     case 0x20:
  1294.     case 0x21:
  1295.     case 0x22:
  1296.     case 0x23:
  1297.     case 0x24:
  1298.     case 0x25:
  1299.     case 0x26:
  1300.     case 0x27:
  1301.     case 0x28:
  1302.     case 0x29:
  1303.     case 0x2a:
  1304.     case 0x2b:
  1305.     case 0x2c:
  1306.     case 0x2d:
  1307.     case 0x2e:
  1308.     case 0x2f:
  1309.       buffer[0] |= 0x10;
  1310.       buffer[1] = 0;
  1311.       buffer[2] = 0;
  1312.       *disp_size = 2;
  1313.       *inst_size = 1;
  1314.       return;
  1315.     default:
  1316.       abort ();
  1317.  
  1318.     case 0x01:
  1319.       *inst_size = 6;
  1320.       *disp_size = 2;
  1321.       break;
  1322.     case 0x06:
  1323.       *inst_size = 8;
  1324.       *disp_size = 2;
  1325.  
  1326.       *buffer++ = 0x26;        /* bne + 8 */
  1327.       *buffer++ = 0x08;
  1328.       break;
  1329.     case 0x07:
  1330.       *inst_size = 8;
  1331.       *disp_size = 2;
  1332.       *buffer++ = 0x27;        /* bne + 8 */
  1333.       *buffer++ = 0x08;
  1334.       break;
  1335.  
  1336.     }
  1337.   *buffer++ = 0xa8 | rn;    /* addq -1,rn */
  1338.   *buffer++ = 0x0c;
  1339.   *buffer++ = 0x04;        /* cmp #0xff:8, rn */
  1340.   *buffer++ = 0xff;
  1341.   *buffer++ = 0x70 | rn;
  1342.   *buffer++ = 0x36;        /* bne ... */
  1343.   *buffer++ = 0;
  1344.   *buffer++ = 0;
  1345. }
  1346.  
  1347. /*
  1348. called after relaxing, change the frags so they know how big they are
  1349. */
  1350. void
  1351. md_convert_frag (headers, seg, fragP)
  1352.      object_headers *headers;
  1353.      segT seg;
  1354.      fragS *fragP;
  1355. {
  1356.   int disp_size = 0;
  1357.   int inst_size = 0;
  1358.   char *buffer = fragP->fr_fix + fragP->fr_literal;
  1359.  
  1360.   switch (fragP->fr_subtype)
  1361.     {
  1362.     case C (BRANCH, BYTE_DISP):
  1363.       disp_size = 1;
  1364.       inst_size = 1;
  1365.       break;
  1366.  
  1367.     case C (SCB_F, BYTE_DISP):
  1368.     case C (SCB_TST, BYTE_DISP):
  1369.       disp_size = 1;
  1370.       inst_size = 2;
  1371.       break;
  1372.  
  1373.       /* Branches to a known 16 bit displacement */
  1374.  
  1375.       /* Turn on the 16bit bit */
  1376.     case C (BRANCH, WORD_DISP):
  1377.     case C (SCB_F, WORD_DISP):
  1378.     case C (SCB_TST, WORD_DISP):
  1379.       wordify_scb (buffer, &disp_size, &inst_size);
  1380.       break;
  1381.  
  1382.     case C (BRANCH, UNDEF_WORD_DISP):
  1383.     case C (SCB_F, UNDEF_WORD_DISP):
  1384.     case C (SCB_TST, UNDEF_WORD_DISP):
  1385.       /* This tried to be relaxed, but didn't manage it, it now needs a
  1386.      fix */
  1387.       wordify_scb (buffer, &disp_size, &inst_size);
  1388.  
  1389.       /* Make a reloc */
  1390.       fix_new (fragP,
  1391.            fragP->fr_fix + inst_size,
  1392.            4,
  1393.            fragP->fr_symbol,
  1394.            fragP->fr_offset,
  1395.            0,
  1396.            R_H8500_PCREL16);
  1397.  
  1398.       fragP->fr_fix += disp_size + inst_size;
  1399.       fragP->fr_var = 0;
  1400.       return;
  1401.       break;
  1402.     default:
  1403.       abort ();
  1404.     }
  1405.   if (inst_size)
  1406.     {
  1407.       /* Get the address of the end of the instruction */
  1408.       int next_inst = fragP->fr_fix + fragP->fr_address + disp_size + inst_size;
  1409.       int targ_addr = (S_GET_VALUE (fragP->fr_symbol) +
  1410.                fragP->fr_offset);
  1411.       int disp = targ_addr - next_inst;
  1412.  
  1413.       md_number_to_chars (buffer + inst_size, disp, disp_size);
  1414.       fragP->fr_fix += disp_size + inst_size;
  1415.       fragP->fr_var = 0;
  1416.     }
  1417. }
  1418.  
  1419. valueT
  1420. md_section_align (seg, size)
  1421.      segT seg ;
  1422.      valueT size;
  1423. {
  1424.   return ((size + (1 << section_alignment[(int) seg]) - 1) 
  1425.       & (-1 << section_alignment[(int) seg]));
  1426.  
  1427. }
  1428.  
  1429. void
  1430. md_apply_fix (fixP, val)
  1431.      fixS *fixP;
  1432.      long val;
  1433. {
  1434.   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  1435.  
  1436.   if (fixP->fx_r_type == 0)
  1437.     {
  1438.       fixP->fx_r_type = fixP->fx_size == 4 ? R_H8500_IMM32 : R_H8500_IMM16;
  1439.     }
  1440.  
  1441.   switch (fixP->fx_r_type)
  1442.     {
  1443.  
  1444.     case R_H8500_IMM8:
  1445.     case R_H8500_PCREL8:
  1446.       *buf++ = val;
  1447.       break;
  1448.     case R_H8500_IMM16:
  1449.     case R_H8500_LOW16:
  1450.     case R_H8500_PCREL16:
  1451.       *buf++ = (val >> 8);
  1452.       *buf++ = val;
  1453.       break;
  1454.     case R_H8500_HIGH8:
  1455.       *buf++ = val >> 16;
  1456.       break;
  1457.     case R_H8500_HIGH16:
  1458.       *buf++ = val >> 24;
  1459.       *buf++ = val >> 16;
  1460.       break;
  1461.     case R_H8500_IMM24:
  1462.       *buf++ = (val >> 16);
  1463.       *buf++ = (val >> 8);
  1464.       *buf++ = val;
  1465.       break;
  1466.     case R_H8500_IMM32:
  1467.       *buf++ = (val >> 24);
  1468.       *buf++ = (val >> 16);
  1469.       *buf++ = (val >> 8);
  1470.       *buf++ = val;
  1471.       break;
  1472.     default:
  1473.       abort ();
  1474.  
  1475.     }
  1476. }
  1477.  
  1478. int md_long_jump_size;
  1479.  
  1480. /*
  1481. called just before address relaxation, return the length
  1482. by which a fragment must grow to reach it's destination
  1483. */
  1484. int
  1485. md_estimate_size_before_relax (fragP, segment_type)
  1486.      register fragS *fragP;
  1487.      register segT segment_type;
  1488. {
  1489.   int what = GET_WHAT (fragP->fr_subtype);
  1490.  
  1491.   switch (fragP->fr_subtype)
  1492.     {
  1493.     default:
  1494.       abort ();
  1495.     case C (BRANCH, UNDEF_BYTE_DISP):
  1496.     case C (SCB_F, UNDEF_BYTE_DISP):
  1497.     case C (SCB_TST, UNDEF_BYTE_DISP):
  1498.       /* used to be a branch to somewhere which was unknown */
  1499.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  1500.     {
  1501.       /* Got a symbol and it's defined in this segment, become byte
  1502.      sized - maybe it will fix up */
  1503.       fragP->fr_subtype = C (what, BYTE_DISP);
  1504.       fragP->fr_var = md_relax_table[C (what, BYTE_DISP)].rlx_length;
  1505.     }
  1506.       else
  1507.     {
  1508.       /* Its got a segment, but its not ours, so it will always be long */
  1509.       fragP->fr_subtype = C (what, UNDEF_WORD_DISP);
  1510.       fragP->fr_var = md_relax_table[C (what, WORD_DISP)].rlx_length;
  1511.       return md_relax_table[C (what, WORD_DISP)].rlx_length;
  1512.     }
  1513.     }
  1514.   return fragP->fr_var;
  1515. }
  1516.  
  1517. /* Put number into target byte order */
  1518.  
  1519. void
  1520. md_number_to_chars (ptr, use, nbytes)
  1521.      char *ptr;
  1522.      valueT use;
  1523.      int nbytes;
  1524. {
  1525.   number_to_chars_bigendian (ptr, use, nbytes);
  1526. }
  1527.  
  1528. long
  1529. md_pcrel_from (fixP)
  1530.      fixS *fixP;
  1531. {
  1532.   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
  1533. }
  1534.  
  1535. /*ARGSUSED*/
  1536. void
  1537. tc_coff_symbol_emit_hook (ignore)
  1538.      symbolS *ignore;
  1539. {
  1540. }
  1541.  
  1542. short
  1543. tc_coff_fix2rtype (fix_ptr)
  1544.      fixS *fix_ptr;
  1545. {
  1546.   if (fix_ptr->fx_r_type == RELOC_32)
  1547.     {
  1548.       /* cons likes to create reloc32's whatever the size of the reloc..
  1549.      */
  1550.       switch (fix_ptr->fx_size)
  1551.     {
  1552.     case 2:
  1553.       return R_H8500_IMM16;
  1554.       break;
  1555.     case 1:
  1556.       return R_H8500_IMM8;
  1557.       break;
  1558.     default:
  1559.       abort ();
  1560.     }
  1561.     }
  1562.   return fix_ptr->fx_r_type;
  1563. }
  1564.  
  1565. void
  1566. tc_reloc_mangle (fix_ptr, intr, base)
  1567.      fixS *fix_ptr;
  1568.      struct internal_reloc *intr;
  1569.      bfd_vma base;
  1570.  
  1571. {
  1572.   symbolS *symbol_ptr;
  1573.  
  1574.   symbol_ptr = fix_ptr->fx_addsy;
  1575.  
  1576.   /* If this relocation is attached to a symbol then it's ok
  1577.      to output it */
  1578.   if (fix_ptr->fx_r_type == RELOC_32)
  1579.     {
  1580.       /* cons likes to create reloc32's whatever the size of the reloc..
  1581.        */
  1582.       switch (fix_ptr->fx_size)
  1583.     {
  1584.     case 2:
  1585.       intr->r_type = R_IMM16;
  1586.       break;
  1587.     case 1:
  1588.       intr->r_type = R_IMM8;
  1589.       break;
  1590.     default:
  1591.       abort ();
  1592.     }
  1593.     }
  1594.   else
  1595.     {
  1596.       intr->r_type = fix_ptr->fx_r_type;
  1597.     }
  1598.  
  1599.   intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
  1600.   intr->r_offset = fix_ptr->fx_offset;
  1601.  
  1602.   /* Turn the segment of the symbol into an offset.  */
  1603.   if (symbol_ptr)
  1604.     {
  1605.       symbolS *dot;
  1606.  
  1607.       dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
  1608.       if (dot)
  1609.     {
  1610.       /*      intr->r_offset -=
  1611.         segment_info[S_GET_SEGMENT(symbol_ptr)].scnhdr.s_paddr;*/
  1612.       intr->r_offset += S_GET_VALUE (symbol_ptr);
  1613.       intr->r_symndx = dot->sy_number;
  1614.     }
  1615.       else
  1616.     {
  1617.       intr->r_symndx = symbol_ptr->sy_number;
  1618.     }
  1619.  
  1620.     }
  1621.   else
  1622.     {
  1623.       intr->r_symndx = -1;
  1624.     }
  1625.  
  1626. }
  1627.  
  1628.  
  1629.  
  1630. int
  1631. start_label (ptr)
  1632.      char *ptr;
  1633. {
  1634.   /* Check for :s.w */
  1635.   if (isalpha (ptr[1]) && ptr[2] == '.')
  1636.     return 0;
  1637.   /* Check for :s */
  1638.   if (isalpha (ptr[1]) && !isalpha (ptr[2]))
  1639.     return 0;
  1640.   return 1;
  1641. }
  1642.  
  1643.  
  1644. int
  1645. tc_coff_sizemachdep (frag)
  1646.      fragS *frag;
  1647. {
  1648.   return md_relax_table[frag->fr_subtype].rlx_length;
  1649. }
  1650.  
  1651. /* end of tc-h8500.c */
  1652.  
  1653.